home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / MacPerl 5.1.3 / Mac_Perl_513_src / perl5.002 / perl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-18  |  49.8 KB  |  2,204 lines  |  [TEXT/MPS ]
  1. /*    perl.c
  2.  *
  3.  *    Copyright (c) 1987-1996 Larry Wall
  4.  *
  5.  *    You may distribute under the terms of either the GNU General Public
  6.  *    License or the Artistic License, as specified in the README file.
  7.  *
  8.  */
  9.  
  10. /*
  11.  * "A ship then new they built for him/of mithril and of elven glass" --Bilbo
  12.  */
  13.  
  14. #include "EXTERN.h"
  15. #include "perl.h"
  16. #include "patchlevel.h"
  17.  
  18. /* Omit -- it causes too much grief on mixed systems.
  19. #ifdef I_UNISTD
  20. #include <unistd.h>
  21. #endif
  22. */
  23.  
  24. dEXT char rcsid[] = "perl.c\nPatch level: ###\n";
  25.  
  26. #ifdef IAMSUID
  27. #ifndef DOSUID
  28. #define DOSUID
  29. #endif
  30. #endif
  31.  
  32. #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
  33. #ifdef DOSUID
  34. #undef DOSUID
  35. #endif
  36. #endif
  37.  
  38. static void find_beginning _((void));
  39. static void incpush _((char *));
  40. static void init_ids _((void));
  41. static void init_debugger _((void));
  42. static void init_lexer _((void));
  43. static void init_main_stash _((void));
  44. static void init_perllib _((void));
  45. static void init_postdump_symbols _((int, char **, char **));
  46. static void init_predump_symbols _((void));
  47. static void init_stacks _((void));
  48. static void nuke_stacks _((void));
  49. static void open_script _((char *, bool, SV *));
  50. static void usage _((char *));
  51. static void validate_suid _((char *));
  52.  
  53. PerlInterpreter *
  54. perl_alloc()
  55. {
  56.     PerlInterpreter *sv_interp;
  57.  
  58.     curinterp = 0;
  59.     New(53, sv_interp, 1, PerlInterpreter);
  60.     return sv_interp;
  61. }
  62.  
  63. void
  64. perl_construct( sv_interp )
  65. register PerlInterpreter *sv_interp;
  66. {
  67.     if (!(curinterp = sv_interp))
  68.     return;
  69.  
  70. #ifdef MULTIPLICITY
  71.     Zero(sv_interp, 1, PerlInterpreter);
  72. #endif
  73.  
  74.     /* Init the real globals? */
  75.     if (!linestr) {
  76.     linestr = NEWSV(65,80);
  77.     sv_upgrade(linestr,SVt_PVIV);
  78.  
  79.     if (!SvREADONLY(&sv_undef)) {
  80.         SvREADONLY_on(&sv_undef);
  81.  
  82.         sv_setpv(&sv_no,No);
  83.         SvNV(&sv_no);
  84.         SvREADONLY_on(&sv_no);
  85.  
  86.         sv_setpv(&sv_yes,Yes);
  87.         SvNV(&sv_yes);
  88.         SvREADONLY_on(&sv_yes);
  89.     }
  90.  
  91.     nrs = newSVpv("\n", 1);
  92.     rs = SvREFCNT_inc(nrs);
  93.  
  94. #ifdef MSDOS
  95.     /*
  96.      * There is no way we can refer to them from Perl so close them to save
  97.      * space.  The other alternative would be to provide STDAUX and STDPRN
  98.      * filehandles.
  99.      */
  100.     (void)fclose(stdaux);
  101.     (void)fclose(stdprn);
  102. #endif
  103.     }
  104.  
  105. #ifdef MULTIPLICITY
  106.     chopset    = " \n-";
  107.     copline    = NOLINE;
  108.     curcop    = &compiling;
  109.     dbargs    = 0;
  110.     dlmax    = 128;
  111.     laststatval    = -1;
  112.     laststype    = OP_STAT;
  113.     maxscream    = -1;
  114.     maxsysfd    = MAXSYSFD;
  115.     rsfp    = Nullfp;
  116.     statname    = Nullsv;
  117.     tmps_floor    = -1;
  118. #endif
  119.  
  120.     init_ids();
  121.  
  122. #if defined(SUBVERSION) && SUBVERSION > 0
  123.     sprintf(patchlevel, "%7.5f", 5.0 + (PATCHLEVEL / 1000.0)
  124.                      + (SUBVERSION / 100000.0));
  125. #else
  126.     sprintf(patchlevel, "%5.3f", 5.0 + (PATCHLEVEL / 1000.0));
  127. #endif
  128.  
  129. #if defined(LOCAL_PATCH_COUNT)
  130.     localpatches = local_patches;    /* For possible -v */
  131. #endif
  132.  
  133.     fdpid = newAV();    /* for remembering popen pids by fd */
  134.     pidstatus = newHV();/* for remembering status of dead pids */
  135.  
  136.     init_stacks();
  137.     ENTER;
  138. }
  139.  
  140. void
  141. perl_destruct(sv_interp)
  142. register PerlInterpreter *sv_interp;
  143. {
  144.     int destruct_level;  /* 0=none, 1=full, 2=full with checks */
  145.     I32 last_sv_count;
  146.     HV *hv;
  147.  
  148.     if (!(curinterp = sv_interp))
  149.     return;
  150.  
  151.     destruct_level = perl_destruct_level;
  152. #ifdef DEBUGGING
  153.     {
  154.     char *s;
  155.     if (s = getenv("PERL_DESTRUCT_LEVEL"))
  156.         destruct_level = atoi(s);
  157.     }
  158. #endif
  159.  
  160.     LEAVE;
  161.     FREETMPS;
  162.  
  163.     /* We must account for everything.  First the syntax tree. */
  164.     if (main_root) {
  165.     curpad = AvARRAY(comppad);
  166.     op_free(main_root);
  167.     main_root = 0;
  168.     }
  169.     if (sv_objcount) {
  170.     /*
  171.      * Try to destruct global references.  We do this first so that the
  172.      * destructors and destructees still exist.  Some sv's might remain.
  173.      * Non-referenced objects are on their own.
  174.      */
  175.     
  176.     dirty = TRUE;
  177.     sv_clean_objs();
  178.     }
  179.  
  180.     if (destruct_level == 0){
  181.  
  182.     DEBUG_P(debprofdump());
  183.     
  184.     /* The exit() function will do everything that needs doing. */
  185.     return;
  186.     }
  187.     
  188.     /* Prepare to destruct main symbol table.  */
  189.     hv = defstash;
  190.     defstash = 0;
  191.     SvREFCNT_dec(hv);
  192.  
  193.     FREETMPS;
  194.     if (destruct_level >= 2) {
  195.     if (scopestack_ix != 0)
  196.         warn("Unbalanced scopes: %d more ENTERs than LEAVEs\n", scopestack_ix);
  197.     if (savestack_ix != 0)
  198.         warn("Unbalanced saves: %d more saves than restores\n", savestack_ix);
  199.     if (tmps_floor != -1)
  200.         warn("Unbalanced tmps: %d more allocs than frees\n", tmps_floor + 1);
  201.     if (cxstack_ix != -1)
  202.         warn("Unbalanced context: %d more PUSHes than POPs\n", cxstack_ix + 1);
  203.     }
  204.  
  205.     /* Now absolutely destruct everything, somehow or other, loops or no. */
  206.     last_sv_count = 0;
  207.     while (sv_count != 0 && sv_count != last_sv_count) {
  208.     last_sv_count = sv_count;
  209.     sv_clean_all();
  210.     }
  211.     if (sv_count != 0)
  212.     warn("Scalars leaked: %d\n", sv_count);
  213.     sv_free_arenas();
  214.     
  215.     linestr = NULL;        /* No SVs have survived, need to clean out */
  216.     if (origfilename)
  217.         Safefree(origfilename);
  218.     nuke_stacks();
  219.     hints = 0;            /* Reset hints. Should hints be per-interpreter ? */
  220.     
  221.     DEBUG_P(debprofdump());
  222. }
  223.  
  224. void
  225. perl_free(sv_interp)
  226. PerlInterpreter *sv_interp;
  227. {
  228.     if (!(curinterp = sv_interp))
  229.     return;
  230.     Safefree(sv_interp);
  231. }
  232. #if !defined(STANDARD_C) && !defined(HAS_GETENV_PROTOTYPE)
  233. char *getenv _((char *)); /* Usually in <stdlib.h> */
  234. #endif
  235.  
  236. int
  237. perl_parse(sv_interp, xsinit, argc, argv, env)
  238. PerlInterpreter *sv_interp;
  239. void (*xsinit)_((void));
  240. int argc;
  241. char **argv;
  242. char **env;
  243. {
  244.     register SV *sv;
  245.     register char *s;
  246.     char *scriptname = NULL;
  247.     VOL bool dosearch = FALSE;
  248.     char *validarg = "";
  249.     AV* comppadlist;
  250.  
  251. #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
  252. #ifdef IAMSUID
  253. #undef IAMSUID
  254.     croak("suidperl is no longer needed since the kernel can now execute\n\
  255. setuid perl scripts securely.\n");
  256. #endif
  257. #endif
  258.  
  259.     if (!(curinterp = sv_interp))
  260.     return 255;
  261.  
  262.     origargv = argv;
  263.     origargc = argc;
  264. #ifndef VMS  /* VMS doesn't have environ array */
  265.     origenviron = environ;
  266. #endif
  267.     e_tmpname = Nullch;
  268.  
  269.     if (do_undump) {
  270.  
  271.     /* Come here if running an undumped a.out. */
  272.  
  273.     origfilename = savepv(argv[0]);
  274.     do_undump = FALSE;
  275.     cxstack_ix = -1;        /* start label stack again */
  276.     init_ids();
  277.     init_postdump_symbols(argc,argv,env);
  278.     return 0;
  279.     }
  280.  
  281.     if (main_root)
  282.     op_free(main_root);
  283.     main_root = 0;
  284.  
  285.     switch (Sigsetjmp(top_env,1)) {
  286.     case 1:
  287. #ifdef VMS
  288.     statusvalue = 255;
  289. #else
  290.     statusvalue = 1;
  291. #endif
  292.     case 2:
  293.     curstash = defstash;
  294.     if (endav)
  295.         calllist(endav);
  296.     return(statusvalue);    /* my_exit() was called */
  297.     case 3:
  298.     fprintf(stderr, "panic: top_env\n");
  299.     return 1;
  300.     }
  301.  
  302.     sv_setpvn(linestr,"",0);
  303.     sv = newSVpv("",0);        /* first used for -I flags */
  304.     SAVEFREESV(sv);
  305.     init_main_stash();
  306.     for (argc--,argv++; argc > 0; argc--,argv++) {
  307.     if (argv[0][0] != '-' || !argv[0][1])
  308.         break;
  309. #ifdef DOSUID
  310.     if (*validarg)
  311.     validarg = " PHOOEY ";
  312.     else
  313.     validarg = argv[0];
  314. #endif
  315.     s = argv[0]+1;
  316.       reswitch:
  317.     switch (*s) {
  318.     case '0':
  319.     case 'F':
  320.     case 'a':
  321.     case 'c':
  322.     case 'd':
  323.     case 'D':
  324.     case 'h':
  325.     case 'i':
  326.     case 'l':
  327.     case 'M':
  328.     case 'm':
  329.     case 'n':
  330.     case 'p':
  331.     case 's':
  332.     case 'T':
  333.     case 'u':
  334.     case 'U':
  335.     case 'v':
  336.     case 'w':
  337.         if (s = moreswitches(s))
  338.         goto reswitch;
  339.         break;
  340.  
  341.     case 'e':
  342. #ifdef macintosh
  343.         /* ignore -e for Dev:Pseudo argument */
  344.         if (argv[1] && !strcmp(argv[1], "Dev:Pseudo"))
  345.             break; 
  346. #endif
  347.         if (euid != uid || egid != gid)
  348.         croak("No -e allowed in setuid scripts");
  349.         if (!e_fp) {
  350.             e_tmpname = savepv(TMPPATH);
  351.         (void)mktemp(e_tmpname);
  352.         if (!*e_tmpname)
  353.             croak("Can't mktemp()");
  354.         e_fp = fopen(e_tmpname,"w");
  355.         if (!e_fp)
  356.             croak("Cannot open temporary file");
  357.         }
  358.         if (argv[1]) {
  359.         fputs(argv[1],e_fp);
  360.         argc--,argv++;
  361.         }
  362.         (void)putc('\n', e_fp);
  363.         break;
  364.     case 'I':
  365.         taint_not("-I");
  366.         sv_catpv(sv,"-");
  367.         sv_catpv(sv,s);
  368.         sv_catpv(sv," ");
  369.         if (*++s) {
  370.         av_push(GvAVn(incgv),newSVpv(s,0));
  371.         }
  372.         else if (argv[1]) {
  373.         av_push(GvAVn(incgv),newSVpv(argv[1],0));
  374.         sv_catpv(sv,argv[1]);
  375.         argc--,argv++;
  376.         sv_catpv(sv," ");
  377.         }
  378.         break;
  379.     case 'P':
  380.         taint_not("-P");
  381.         preprocess = TRUE;
  382.         s++;
  383.         goto reswitch;
  384.     case 'S':
  385.         taint_not("-S");
  386.         dosearch = TRUE;
  387.         s++;
  388.         goto reswitch;
  389.     case 'V':
  390.         if (!preambleav)
  391.         preambleav = newAV();
  392.         av_push(preambleav, newSVpv("use Config qw(myconfig config_vars)",0));
  393.         if (*++s != ':')  {
  394.         Sv = newSVpv("print myconfig(),'@INC: '.\"@INC\\n\"",0);
  395.         }
  396.         else {
  397.         Sv = newSVpv("config_vars(qw(",0);
  398.         sv_catpv(Sv, ++s);
  399.         sv_catpv(Sv, "))");
  400.         s += strlen(s);
  401.         }
  402.         av_push(preambleav, Sv);
  403.         scriptname = BIT_BUCKET;    /* don't look for script or read stdin */
  404.         goto reswitch;
  405.     case 'x':
  406.         doextract = TRUE;
  407.         s++;
  408.         if (*s)
  409.         cddir = savepv(s);
  410.         break;
  411.     case '-':
  412.         argc--,argv++;
  413.         goto switch_end;
  414.     case 0:
  415.         break;
  416.     default:
  417.         croak("Unrecognized switch: -%s",s);
  418.     }
  419.     }
  420.   switch_end:
  421.     if (!scriptname)
  422.     scriptname = argv[0];
  423.     if (e_fp) {
  424.     if (Fflush(e_fp) || ferror(e_fp) || fclose(e_fp))
  425.         croak("Can't write to temp file for -e: %s", Strerror(errno));
  426.     e_fp = Nullfp;
  427.     argc++,argv--;
  428.     scriptname = e_tmpname;
  429.     }
  430.     else if (scriptname == Nullch) {
  431. #ifdef MSDOS
  432.     if ( isatty(fileno(stdin)) )
  433.         moreswitches("v");
  434. #endif
  435.     scriptname = "-";
  436.     }
  437.  
  438.     init_perllib();
  439.  
  440.     open_script(scriptname,dosearch,sv);
  441.  
  442.     validate_suid(validarg);
  443.  
  444. #ifdef macintosh
  445.     if (doextract || gAlwaysExtract)
  446. #else
  447.     if (doextract)
  448. #endif
  449.     find_beginning();
  450.  
  451.     compcv = (CV*)NEWSV(1104,0);
  452.     sv_upgrade((SV *)compcv, SVt_PVCV);
  453.  
  454.     pad = newAV();
  455.     comppad = pad;
  456.     av_push(comppad, Nullsv);
  457.     curpad = AvARRAY(comppad);
  458.     padname = newAV();
  459.     comppad_name = padname;
  460.     comppad_name_fill = 0;
  461.     min_intro_pending = 0;
  462.     padix = 0;
  463.  
  464.     comppadlist = newAV();
  465.     AvREAL_off(comppadlist);
  466.     av_store(comppadlist, 0, (SV*)comppad_name);
  467.     av_store(comppadlist, 1, (SV*)comppad);
  468.     CvPADLIST(compcv) = comppadlist;
  469.  
  470.     if (xsinit)
  471.     (*xsinit)();    /* in case linked C routines want magical variables */
  472. #ifdef VMS
  473.     init_os_extras();
  474. #endif
  475.  
  476.     init_predump_symbols();
  477.     if (!do_undump)
  478.     init_postdump_symbols(argc,argv,env);
  479.  
  480.     init_lexer();
  481.  
  482.     /* now parse the script */
  483.  
  484.     error_count = 0;
  485. #ifdef macintosh
  486.     if (gSyntaxError = (yyparse() || error_count)) {
  487.     if (minus_c)
  488.         croak("%s had compilation errors.\n", MPWFileName(origfilename));
  489.     else 
  490.         croak("Execution of %s aborted due to compilation errors.\n",
  491.         MPWFileName(origfilename));
  492.     }
  493. #else
  494.     if (yyparse() || error_count) {
  495.     if (minus_c)
  496.         croak("%s had compilation errors.\n", origfilename);
  497.     else {
  498.         croak("Execution of %s aborted due to compilation errors.\n",
  499.         origfilename);
  500.     }
  501.     }
  502. #endif
  503.     curcop->cop_line = 0;
  504.     curstash = defstash;
  505.     preprocess = FALSE;
  506.     if (e_tmpname) {
  507.     (void)UNLINK(e_tmpname);
  508.     Safefree(e_tmpname);
  509.     e_tmpname = Nullch;
  510.     }
  511.  
  512.     /* now that script is parsed, we can modify record separator */
  513.     SvREFCNT_dec(rs);
  514.     rs = SvREFCNT_inc(nrs);
  515.     sv_setsv(GvSV(gv_fetchpv("/", TRUE, SVt_PV)), rs);
  516.  
  517.     if (do_undump)
  518.     my_unexec();
  519.  
  520.     if (dowarn)
  521.     gv_check(defstash);
  522.  
  523.     LEAVE;
  524.     FREETMPS;
  525.  
  526. #ifdef DEBUGGING_MSTATS
  527.     if ((s=getenv("PERL_DEBUG_MSTATS")) && atoi(s) >= 2)
  528.     dump_mstats("after compilation:");
  529. #endif
  530.  
  531.     ENTER;
  532.     restartop = 0;
  533.     return 0;
  534. }
  535.  
  536. int
  537. perl_run(sv_interp)
  538. PerlInterpreter *sv_interp;
  539. {
  540.     if (!(curinterp = sv_interp))
  541.     return 255;
  542.     switch (Sigsetjmp(top_env,1)) {
  543.     case 1:
  544.     cxstack_ix = -1;        /* start context stack again */
  545.     break;
  546.     case 2:
  547.     curstash = defstash;
  548.     if (endav)
  549.         calllist(endav);
  550.     FREETMPS;
  551. #ifdef DEBUGGING_MSTATS
  552.     if (getenv("PERL_DEBUG_MSTATS"))
  553.         dump_mstats("after execution:  ");
  554. #endif
  555.     return(statusvalue);        /* my_exit() was called */
  556.     case 3:
  557.     if (!restartop) {
  558.         fprintf(stderr, "panic: restartop\n");
  559.         FREETMPS;
  560.         return 1;
  561.     }
  562.     if (stack != mainstack) {
  563.         dSP;
  564.         SWITCHSTACK(stack, mainstack);
  565.     }
  566.     break;
  567.     }
  568.  
  569.     if (!restartop) {
  570.     DEBUG_x(dump_all());
  571.     DEBUG(fprintf(Perl_debug_log,"\nEXECUTING...\n\n"));
  572.  
  573.     if (minus_c) {
  574. #ifdef macintosh
  575.         fprintf(stderr,"# %s syntax OK\n", MPWFileName(origfilename));
  576. #else
  577.         fprintf(stderr,"%s syntax OK\n", origfilename);
  578. #endif
  579.         my_exit(0);
  580.     }
  581.     if (perldb && DBsingle)
  582.        sv_setiv(DBsingle, 1); 
  583.     }
  584.  
  585.     /* do it */
  586.  
  587.     if (restartop) {
  588.     op = restartop;
  589.     restartop = 0;
  590.     runops();
  591.     }
  592.     else if (main_start) {
  593.     op = main_start;
  594.     runops();
  595.     }
  596.  
  597.     my_exit(0);
  598.     return 0;
  599. }
  600.  
  601. void
  602. my_exit(status)
  603. U32 status;
  604. {
  605.     register CONTEXT *cx;
  606.     I32 gimme;
  607.     SV **newsp;
  608.  
  609.     statusvalue = FIXSTATUS(status);
  610.     if (cxstack_ix >= 0) {
  611.     if (cxstack_ix > 0)
  612.         dounwind(0);
  613.     POPBLOCK(cx,curpm);
  614.     LEAVE;
  615.     }
  616.     Siglongjmp(top_env, 2);
  617. }
  618.  
  619. SV*
  620. perl_get_sv(name, create)
  621. char* name;
  622. I32 create;
  623. {
  624.     GV* gv = gv_fetchpv(name, create, SVt_PV);
  625.     if (gv)
  626.     return GvSV(gv);
  627.     return Nullsv;
  628. }
  629.  
  630. AV*
  631. perl_get_av(name, create)
  632. char* name;
  633. I32 create;
  634. {
  635.     GV* gv = gv_fetchpv(name, create, SVt_PVAV);
  636.     if (create)
  637.         return GvAVn(gv);
  638.     if (gv)
  639.     return GvAV(gv);
  640.     return Nullav;
  641. }
  642.  
  643. HV*
  644. perl_get_hv(name, create)
  645. char* name;
  646. I32 create;
  647. {
  648.     GV* gv = gv_fetchpv(name, create, SVt_PVHV);
  649.     if (create)
  650.         return GvHVn(gv);
  651.     if (gv)
  652.     return GvHV(gv);
  653.     return Nullhv;
  654. }
  655.  
  656. CV*
  657. perl_get_cv(name, create)
  658. char* name;
  659. I32 create;
  660. {
  661.     GV* gv = gv_fetchpv(name, create, SVt_PVCV);
  662.     if (create && !GvCV(gv))
  663.         return newSUB(start_subparse(),
  664.               newSVOP(OP_CONST, 0, newSVpv(name,0)),
  665.               Nullop,
  666.               Nullop);
  667.     if (gv)
  668.     return GvCV(gv);
  669.     return Nullcv;
  670. }
  671.  
  672. /* Be sure to refetch the stack pointer after calling these routines. */
  673.  
  674. I32
  675. perl_call_argv(subname, flags, argv)
  676. char *subname;
  677. I32 flags;        /* See G_* flags in cop.h */
  678. register char **argv;    /* null terminated arg list */
  679. {
  680.     dSP;
  681.  
  682.     PUSHMARK(sp);
  683.     if (argv) {
  684.     while (*argv) {
  685.         XPUSHs(sv_2mortal(newSVpv(*argv,0)));
  686.         argv++;
  687.     }
  688.     PUTBACK;
  689.     }
  690.     return perl_call_pv(subname, flags);
  691. }
  692.  
  693. I32
  694. perl_call_pv(subname, flags)
  695. char *subname;        /* name of the subroutine */
  696. I32 flags;        /* See G_* flags in cop.h */
  697. {
  698.     return perl_call_sv((SV*)perl_get_cv(subname, TRUE), flags);
  699. }
  700.  
  701. I32
  702. perl_call_method(methname, flags)
  703. char *methname;        /* name of the subroutine */
  704. I32 flags;        /* See G_* flags in cop.h */
  705. {
  706.     dSP;
  707.     OP myop;
  708.     if (!op)
  709.     op = &myop;
  710.     XPUSHs(sv_2mortal(newSVpv(methname,0)));
  711.     PUTBACK;
  712.     pp_method();
  713.     return perl_call_sv(*stack_sp--, flags);
  714. }
  715.  
  716. /* May be called with any of a CV, a GV, or an SV containing the name. */
  717. I32
  718. perl_call_sv(sv, flags)
  719. SV* sv;
  720. I32 flags;        /* See G_* flags in cop.h */
  721. {
  722.     LOGOP myop;        /* fake syntax tree node */
  723.     SV** sp = stack_sp;
  724.     I32 oldmark = TOPMARK;
  725.     I32 retval;
  726.     Sigjmp_buf oldtop;
  727.     I32 oldscope;
  728.     
  729.     if (flags & G_DISCARD) {
  730.     ENTER;
  731.     SAVETMPS;
  732.     }
  733.  
  734.     SAVESPTR(op);
  735.     op = (OP*)&myop;
  736.     Zero(op, 1, LOGOP);
  737.     EXTEND(stack_sp, 1);
  738.     *++stack_sp = sv;
  739.     oldscope = scopestack_ix;
  740.  
  741.     if (!(flags & G_NOARGS))
  742.     myop.op_flags = OPf_STACKED;
  743.     myop.op_next = Nullop;
  744.     myop.op_flags |= OPf_KNOW;
  745.     if (flags & G_ARRAY)
  746.       myop.op_flags |= OPf_LIST;
  747.  
  748.     if (flags & G_EVAL) {
  749.     Copy(top_env, oldtop, 1, Sigjmp_buf);
  750.  
  751.     cLOGOP->op_other = op;
  752.     markstack_ptr--;
  753.     /* we're trying to emulate pp_entertry() here */
  754.     {
  755.         register CONTEXT *cx;
  756.         I32 gimme = GIMME;
  757.         
  758.         ENTER;
  759.         SAVETMPS;
  760.         
  761.         push_return(op->op_next);
  762.         PUSHBLOCK(cx, CXt_EVAL, stack_sp);
  763.         PUSHEVAL(cx, 0, 0);
  764.         eval_root = op;             /* Only needed so that goto works right. */
  765.         
  766.         in_eval = 1;
  767.         if (flags & G_KEEPERR)
  768.         in_eval |= 4;
  769.         else
  770.         sv_setpv(GvSV(errgv),"");
  771.     }
  772.     markstack_ptr++;
  773.  
  774.     restart:
  775.     switch (Sigsetjmp(top_env,1)) {
  776.     case 0:
  777.         break;
  778.     case 1:
  779. #ifdef VMS
  780.         statusvalue = 255;    /* XXX I don't think we use 1 anymore. */
  781. #else
  782.     statusvalue = 1;
  783. #endif
  784.         /* FALL THROUGH */
  785.     case 2:
  786.         /* my_exit() was called */
  787.         curstash = defstash;
  788.         FREETMPS;
  789.         Copy(oldtop, top_env, 1, Sigjmp_buf);
  790.         if (statusvalue)
  791.         croak("Callback called exit");
  792.         my_exit(statusvalue);
  793.         /* NOTREACHED */
  794.     case 3:
  795.         if (restartop) {
  796.         op = restartop;
  797.         restartop = 0;
  798.         goto restart;
  799.         }
  800.         stack_sp = stack_base + oldmark;
  801.         if (flags & G_ARRAY)
  802.         retval = 0;
  803.         else {
  804.         retval = 1;
  805.         *++stack_sp = &sv_undef;
  806.         }
  807.         goto cleanup;
  808.     }
  809.     }
  810.  
  811.     if (op == (OP*)&myop)
  812.     op = pp_entersub();
  813.     if (op)
  814.     runops();
  815.     retval = stack_sp - (stack_base + oldmark);
  816.     if ((flags & G_EVAL) && !(flags & G_KEEPERR))
  817.     sv_setpv(GvSV(errgv),"");
  818.  
  819.   cleanup:
  820.     if (flags & G_EVAL) {
  821.     if (scopestack_ix > oldscope) {
  822.         SV **newsp;
  823.         PMOP *newpm;
  824.         I32 gimme;
  825.         register CONTEXT *cx;
  826.         I32 optype;
  827.  
  828.         POPBLOCK(cx,newpm);
  829.         POPEVAL(cx);
  830.         pop_return();
  831.         curpm = newpm;
  832.         LEAVE;
  833.     }
  834.     Copy(oldtop, top_env, 1, Sigjmp_buf);
  835.     }
  836.     if (flags & G_DISCARD) {
  837.     stack_sp = stack_base + oldmark;
  838.     retval = 0;
  839.     FREETMPS;
  840.     LEAVE;
  841.     }
  842.     return retval;
  843. }
  844.  
  845. /* Eval a string. */
  846.  
  847. I32
  848. perl_eval_sv(sv, flags)
  849. SV* sv;
  850. I32 flags;        /* See G_* flags in cop.h */
  851. {
  852.     UNOP myop;        /* fake syntax tree node */
  853.     SV** sp = stack_sp;
  854.     I32 oldmark = sp - stack_base;
  855.     I32 retval;
  856.     Sigjmp_buf oldtop;
  857.     I32 oldscope;
  858.     
  859.     if (flags & G_DISCARD) {
  860.     ENTER;
  861.     SAVETMPS;
  862.     }
  863.  
  864.     SAVESPTR(op);
  865.     op = (OP*)&myop;
  866.     Zero(op, 1, UNOP);
  867.     EXTEND(stack_sp, 1);
  868.     *++stack_sp = sv;
  869.     oldscope = scopestack_ix;
  870.  
  871.     if (!(flags & G_NOARGS))
  872.     myop.op_flags = OPf_STACKED;
  873.     myop.op_next = Nullop;
  874.     myop.op_flags |= OPf_KNOW;
  875.     if (flags & G_ARRAY)
  876.       myop.op_flags |= OPf_LIST;
  877.  
  878.     Copy(top_env, oldtop, 1, Sigjmp_buf);
  879.  
  880. restart:
  881.     switch (Sigsetjmp(top_env,1)) {
  882.     case 0:
  883.     break;
  884.     case 1:
  885. #ifdef VMS
  886.     statusvalue = 255;    /* XXX I don't think we use 1 anymore. */
  887. #else
  888.     statusvalue = 1;
  889. #endif
  890.     /* FALL THROUGH */
  891.     case 2:
  892.     /* my_exit() was called */
  893.     curstash = defstash;
  894.     FREETMPS;
  895.     Copy(oldtop, top_env, 1, Sigjmp_buf);
  896.     if (statusvalue)
  897.         croak("Callback called exit");
  898.     my_exit(statusvalue);
  899.     /* NOTREACHED */
  900.     case 3:
  901.     if (restartop) {
  902.         op = restartop;
  903.         restartop = 0;
  904.         goto restart;
  905.     }
  906.     stack_sp = stack_base + oldmark;
  907.     if (flags & G_ARRAY)
  908.         retval = 0;
  909.     else {
  910.         retval = 1;
  911.         *++stack_sp = &sv_undef;
  912.     }
  913.     goto cleanup;
  914.     }
  915.  
  916.     if (op == (OP*)&myop)
  917.     op = pp_entereval();
  918.     if (op)
  919.     runops();
  920.     retval = stack_sp - (stack_base + oldmark);
  921.     if ((flags & G_EVAL) && !(flags & G_KEEPERR))
  922.     sv_setpv(GvSV(errgv),"");
  923.  
  924.   cleanup:
  925.     Copy(oldtop, top_env, 1, Sigjmp_buf);
  926.     if (flags & G_DISCARD) {
  927.     stack_sp = stack_base + oldmark;
  928.     retval = 0;
  929.     FREETMPS;
  930.     LEAVE;
  931.     }
  932.     return retval;
  933. }
  934.  
  935. /* Require a module. */
  936.  
  937. void
  938. perl_require_pv(pv)
  939. char* pv;
  940. {
  941.     SV* sv = sv_newmortal();
  942.     sv_setpv(sv, "require '");
  943.     sv_catpv(sv, pv);
  944.     sv_catpv(sv, "'");
  945.     perl_eval_sv(sv, G_DISCARD);
  946. }
  947.  
  948. void
  949. magicname(sym,name,namlen)
  950. char *sym;
  951. char *name;
  952. I32 namlen;
  953. {
  954.     register GV *gv;
  955.  
  956.     if (gv = gv_fetchpv(sym,TRUE, SVt_PV))
  957.     sv_magic(GvSV(gv), (SV*)gv, 0, name, namlen);
  958. }
  959.  
  960. #if defined(macintosh)
  961. # define PERLLIB_SEP ','
  962. #else
  963. # if defined(DOSISH)
  964. #     define PERLLIB_SEP ';'
  965. # else
  966. #   if defined(VMS)
  967. #     define PERLLIB_SEP '|'
  968. #   else
  969. #     define PERLLIB_SEP ':'
  970. #   endif
  971. # endif
  972. #endif
  973.  
  974. static void
  975. incpush(p)
  976. char *p;
  977. {
  978.     char *s;
  979.  
  980.     if (!p)
  981.     return;
  982.  
  983.     /* Break at all separators */
  984.     while (*p) {
  985.     /* First, skip any consecutive separators */
  986.     while ( *p == PERLLIB_SEP ) {
  987.         /* Uncomment the next line for PATH semantics */
  988.         /* av_push(GvAVn(incgv), newSVpv(".", 1)); */
  989.         p++;
  990.     }
  991.     if ( (s = strchr(p, PERLLIB_SEP)) != Nullch ) {
  992.         av_push(GvAVn(incgv), newSVpv(p, (STRLEN)(s - p)));
  993.         p = s + 1;
  994.     } else {
  995.         av_push(GvAVn(incgv), newSVpv(p, 0));
  996.         break;
  997.     }
  998.     }
  999. }
  1000.  
  1001. static void
  1002. usage(name)        /* XXX move this out into a module ? */
  1003. char *name;
  1004. {
  1005.     /* This message really ought to be max 23 lines.
  1006.      * Removed -h because the user already knows that opton. Others? */
  1007.     printf("\nUsage: %s [switches] [--] [programfile] [arguments]", name);
  1008.     printf("\n  -0[octal]       specify record separator (\\0, if no argument)");
  1009.     printf("\n  -a              autosplit mode with -n or -p (splits $_ into @F)");
  1010.     printf("\n  -c              check syntax only (runs BEGIN and END blocks)");
  1011.     printf("\n  -d[:debugger]   run scripts under debugger");
  1012.     printf("\n  -D[number/list] set debugging flags (argument is a bit mask or flags)");
  1013.     printf("\n  -e 'command'    one line of script. Several -e's allowed. Omit [programfile].");
  1014.     printf("\n  -F/pattern/     split() pattern for autosplit (-a). The //'s are optional.");
  1015.     printf("\n  -i[extension]   edit <> files in place (make backup if extension supplied)");
  1016.     printf("\n  -Idirectory     specify @INC/#include directory (may be used more then once)");
  1017.     printf("\n  -l[octal]       enable line ending processing, specifies line teminator");
  1018.     printf("\n  -[mM][-]module.. executes `use/no module...' before executing your script.");
  1019.     printf("\n  -n              assume 'while (<>) { ... }' loop arround your script");
  1020.     printf("\n  -p              assume loop like -n but print line also like sed");
  1021.     printf("\n  -P              run script through C preprocessor before compilation");
  1022. #ifdef OS2
  1023.     printf("\n  -R              enable REXX variable pool");
  1024. #endif      
  1025.     printf("\n  -s              enable some switch parsing for switches after script name");
  1026.     printf("\n  -S              look for the script using PATH environment variable");
  1027.     printf("\n  -T              turn on tainting checks");
  1028.     printf("\n  -u              dump core after parsing script");
  1029.     printf("\n  -U              allow unsafe operations");
  1030.     printf("\n  -v              print version number and patchlevel of perl");
  1031.     printf("\n  -V[:variable]   print perl configuration information");
  1032.     printf("\n  -w              TURN WARNINGS ON FOR COMPILATION OF YOUR SCRIPT.");
  1033.     printf("\n  -x[directory]   strip off text before #!perl line and perhaps cd to directory\n");
  1034. }
  1035.  
  1036. /* This routine handles any switches that can be given during run */
  1037.  
  1038. char *
  1039. moreswitches(s)
  1040. char *s;
  1041. {
  1042.     I32 numlen;
  1043.     U32 rschar;
  1044.  
  1045.     switch (*s) {
  1046.     case '0':
  1047.     rschar = scan_oct(s, 4, &numlen);
  1048.     SvREFCNT_dec(nrs);
  1049.     if (rschar & ~((U8)~0))
  1050.         nrs = &sv_undef;
  1051.     else if (!rschar && numlen >= 2)
  1052.         nrs = newSVpv("", 0);
  1053.     else {
  1054.         char ch = rschar;
  1055.         nrs = newSVpv(&ch, 1);
  1056.     }
  1057.     return s + numlen;
  1058.     case 'F':
  1059.     minus_F = TRUE;
  1060.     splitstr = savepv(s + 1);
  1061.     s += strlen(s);
  1062.     return s;
  1063.     case 'a':
  1064.     minus_a = TRUE;
  1065.     s++;
  1066.     return s;
  1067.     case 'c':
  1068.     minus_c = TRUE;
  1069.     s++;
  1070.     return s;
  1071.     case 'd':
  1072.     taint_not("-d");
  1073.     s++;
  1074.     if (*s == ':' || *s == '=')  {
  1075.         sprintf(buf, "use Devel::%s;", ++s);
  1076.         s += strlen(s);
  1077.         my_setenv("PERL5DB",buf);
  1078.     }
  1079.     if (!perldb) {
  1080.         perldb = TRUE;
  1081.         init_debugger();
  1082.     }
  1083.     return s;
  1084.     case 'D':
  1085. #ifdef DEBUGGING
  1086.     taint_not("-D");
  1087.     if (isALPHA(s[1])) {
  1088.         static char debopts[] = "psltocPmfrxuLHXD";
  1089.         char *d;
  1090.  
  1091.         for (s++; *s && (d = strchr(debopts,*s)); s++)
  1092.         debug |= 1 << (d - debopts);
  1093.     }
  1094.     else {
  1095.         debug = atoi(s+1);
  1096.         for (s++; isDIGIT(*s); s++) ;
  1097.     }
  1098.     debug |= 0x80000000;
  1099. #else
  1100.     warn("Recompile perl with -DDEBUGGING to use -D switch\n");
  1101.     for (s++; isALNUM(*s); s++) ;
  1102. #endif
  1103.     /*SUPPRESS 530*/
  1104.     return s;
  1105.     case 'h':
  1106.     usage(origargv[0]);    
  1107.     exit(0);
  1108.     case 'i':
  1109.     if (inplace)
  1110.         Safefree(inplace);
  1111.     inplace = savepv(s+1);
  1112.     /*SUPPRESS 530*/
  1113.     for (s = inplace; *s && !isSPACE(*s); s++) ;
  1114.     *s = '\0';
  1115.     break;
  1116.     case 'I':
  1117.     taint_not("-I");
  1118.     if (*++s) {
  1119.         char *e;
  1120.         for (e = s; *e && !isSPACE(*e); e++) ;
  1121.         av_push(GvAVn(incgv),newSVpv(s,e-s));
  1122.         if (*e)
  1123.         return e;
  1124.     }
  1125.     else
  1126.         croak("No space allowed after -I");
  1127.     break;
  1128.     case 'l':
  1129.     minus_l = TRUE;
  1130.     s++;
  1131.     if (ors)
  1132.         Safefree(ors);
  1133.     if (isDIGIT(*s)) {
  1134.         ors = savepv("\n");
  1135.         orslen = 1;
  1136.         *ors = scan_oct(s, 3 + (*s == '0'), &numlen);
  1137.         s += numlen;
  1138.     }
  1139.     else {
  1140.         if (RsPARA(nrs)) {
  1141.         ors = savepvn("\n\n", 2);
  1142.         orslen = 2;
  1143.         }
  1144.         else
  1145.         ors = SvPV(nrs, orslen);
  1146.     }
  1147.     return s;
  1148.     case 'M':
  1149.     taint_not("-M");    /* XXX ? */
  1150.     /* FALL THROUGH */
  1151.     case 'm':
  1152.     taint_not("-m");    /* XXX ? */
  1153.     if (*++s) {
  1154.         char *start;
  1155.         char *use = "use ";
  1156.         /* -M-foo == 'no foo'    */
  1157.         if (*s == '-') { use = "no "; ++s; }
  1158.         Sv = newSVpv(use,0);
  1159.         start = s;
  1160.         /* We allow -M'Module qw(Foo Bar)'    */
  1161.         while(isALNUM(*s) || *s==':') ++s;
  1162.         if (*s != '=') {
  1163.         sv_catpv(Sv, start);
  1164.         if (*(start-1) == 'm') {
  1165.             if (*s != '\0')
  1166.             croak("Can't use '%c' after -mname", *s);
  1167.             sv_catpv( Sv, " ()");
  1168.         }
  1169.         } else {
  1170.         sv_catpvn(Sv, start, s-start);
  1171.         sv_catpv(Sv, " split(/,/,q{");
  1172.         sv_catpv(Sv, ++s);
  1173.         sv_catpv(Sv,    "})");
  1174.         }
  1175.         s += strlen(s);
  1176.         if (preambleav == NULL)
  1177.         preambleav = newAV();
  1178.         av_push(preambleav, Sv);
  1179.     }
  1180.     else
  1181.         croak("No space allowed after -%c", *(s-1));
  1182.     return s;
  1183.     case 'n':
  1184.     minus_n = TRUE;
  1185.     s++;
  1186.     return s;
  1187.     case 'p':
  1188.     minus_p = TRUE;
  1189.     s++;
  1190.     return s;
  1191.     case 's':
  1192.     taint_not("-s");
  1193.     doswitches = TRUE;
  1194.     s++;
  1195.     return s;
  1196.     case 'T':
  1197.     tainting = TRUE;
  1198.     s++;
  1199.     return s;
  1200.     case 'u':
  1201.     do_undump = TRUE;
  1202.     s++;
  1203.     return s;
  1204.     case 'U':
  1205.     unsafe = TRUE;
  1206.     s++;
  1207.     return s;
  1208.     case 'v':
  1209. #if defined(SUBVERSION) && SUBVERSION > 0
  1210.     printf("\nThis is perl, version 5.%03d_%02d", PATCHLEVEL, SUBVERSION);
  1211. #else
  1212.     printf("\nThis is perl, version %s",patchlevel);
  1213. #endif
  1214.  
  1215. #if defined(DEBUGGING) || defined(EMBED) || defined(MULTIPLICITY)
  1216.     fputs(" with", stdout);
  1217. #ifdef DEBUGGING
  1218.     fputs(" DEBUGGING", stdout);
  1219. #endif
  1220. #ifdef EMBED
  1221.     fputs(" EMBED", stdout);
  1222. #endif
  1223. #ifdef MULTIPLICITY
  1224.     fputs(" MULTIPLICITY", stdout);
  1225. #endif
  1226. #endif
  1227.  
  1228. #if defined(LOCAL_PATCH_COUNT)
  1229.     if (LOCAL_PATCH_COUNT > 0)
  1230.     {    int i;
  1231.     fputs("\n\tLocally applied patches:\n", stdout);
  1232.     for (i = 1; i <= LOCAL_PATCH_COUNT; i++) {
  1233.         if (localpatches[i])
  1234.             fprintf(stdout, "\t  %s\n", localpatches[i]);
  1235.     }
  1236.     }
  1237. #endif
  1238.     printf("\n\tbuilt under %s",OSNAME);
  1239. #ifdef __DATE__
  1240. #  ifdef __TIME__
  1241.     printf(" at %s %s",__DATE__,__TIME__);
  1242. #  else
  1243.     printf(" on %s",__DATE__);
  1244. #  endif
  1245. #endif
  1246.     fputs("\n\nCopyright 1987-1996, Larry Wall\n",stdout);
  1247. #ifdef macintosh
  1248.         fputs("Macintosh port Copyright 1991-1996, Matthias Neeracher\n", stdout);
  1249. #endif
  1250. #ifdef MSDOS
  1251.     fputs("MS-DOS port Copyright (c) 1989, 1990, Diomidis Spinellis\n",
  1252.     stdout);
  1253. #endif
  1254. #ifdef OS2
  1255.     fputs("OS/2 port Copyright (c) 1990, 1991, Raymond Chen, Kai Uwe Rommel\n"
  1256.         "Version 5 port Copyright (c) 1994-1995, Andreas Kaiser\n", stdout);
  1257. #endif
  1258. #ifdef atarist
  1259.     fputs("atariST series port, ++jrb  bammi@cadence.com\n", stdout);
  1260. #endif
  1261.     fputs("\n\
  1262. Perl may be copied only under the terms of either the Artistic License or the\n\
  1263. GNU General Public License, which may be found in the Perl 5.0 source kit.\n\n",stdout);
  1264. #ifdef MSDOS
  1265.         usage(origargv[0]);
  1266. #endif
  1267. #ifdef macintosh
  1268.     my_exit(0);
  1269. #else
  1270.     exit(0);
  1271. #endif
  1272.     case 'w':
  1273.     dowarn = TRUE;
  1274.     s++;
  1275.     return s;
  1276.     case '*':
  1277.     case ' ':
  1278.     if (s[1] == '-')    /* Additional switches on #! line. */
  1279.         return s+2;
  1280.     break;
  1281.     case '-':
  1282.     case 0:
  1283.     case '\n':
  1284.     case '\t':
  1285.     break;
  1286.     case 'P':
  1287.     if (preprocess)
  1288.         return s+1;
  1289.     /* FALL THROUGH */
  1290.     default:
  1291.     croak("Can't emulate -%.1s on #! line",s);
  1292.     }
  1293.     return Nullch;
  1294. }
  1295.  
  1296. /* compliments of Tom Christiansen */
  1297.  
  1298. /* unexec() can be found in the Gnu emacs distribution */
  1299.  
  1300. void
  1301. my_unexec()
  1302. {
  1303. #ifdef UNEXEC
  1304.     int    status;
  1305.     extern int etext;
  1306.  
  1307.     sprintf (buf, "%s.perldump", origfilename);
  1308.     sprintf (tokenbuf, "%s/perl", BIN);
  1309.  
  1310.     status = unexec(buf, tokenbuf, &etext, sbrk(0), 0);
  1311.     if (status)
  1312.     fprintf(stderr, "unexec of %s into %s failed!\n", tokenbuf, buf);
  1313.     exit(status);
  1314. #else
  1315. # ifdef VMS
  1316. #    include <lib$routines.h>
  1317.      lib$signal(SS$_DEBUG);  /* ssdef.h #included from vmsish.h */
  1318. # else
  1319.     ABORT();        /* for use with undump */
  1320. # endif
  1321. #endif
  1322. }
  1323.  
  1324. static void
  1325. init_main_stash()
  1326. {
  1327.     GV *gv;
  1328.     curstash = defstash = newHV();
  1329.     curstname = newSVpv("main",4);
  1330.     gv = gv_fetchpv("main::",TRUE, SVt_PVHV);
  1331.     SvREFCNT_dec(GvHV(gv));
  1332.     GvHV(gv) = (HV*)SvREFCNT_inc(defstash);
  1333.     SvREADONLY_on(gv);
  1334.     HvNAME(defstash) = savepv("main");
  1335.     incgv = gv_HVadd(gv_AVadd(gv_fetchpv("INC",TRUE, SVt_PVAV)));
  1336.     GvMULTI_on(incgv);
  1337.     defgv = gv_fetchpv("_",TRUE, SVt_PVAV);
  1338.     errgv = gv_HVadd(gv_fetchpv("@", TRUE, SVt_PV));
  1339.     GvMULTI_on(errgv);
  1340.     curstash = defstash;
  1341.     compiling.cop_stash = defstash;
  1342.     debstash = GvHV(gv_fetchpv("DB::", GV_ADDMULTI, SVt_PVHV));
  1343.     /* We must init $/ before switches are processed. */
  1344.     sv_setpvn(GvSV(gv_fetchpv("/", TRUE, SVt_PV)), "\n", 1);
  1345. }
  1346.  
  1347. #ifdef CAN_PROTOTYPE
  1348. static void
  1349. open_script(char *scriptname, bool dosearch, SV *sv)
  1350. #else
  1351. static void
  1352. open_script(scriptname,dosearch,sv)
  1353. char *scriptname;
  1354. bool dosearch;
  1355. SV *sv;
  1356. #endif
  1357. {
  1358.     char *xfound = Nullch;
  1359.     char *xfailed = Nullch;
  1360.     register char *s;
  1361.     I32 len;
  1362.     int retval;
  1363. #if defined(DOSISH) && !defined(OS2) && !defined(atarist)
  1364. #define SEARCH_EXTS ".bat", ".cmd", NULL
  1365. #endif
  1366. #ifdef VMS
  1367. #  define SEARCH_EXTS ".pl", ".com", NULL
  1368. #endif
  1369.     /* additional extensions to try in each dir if scriptname not found */
  1370. #ifdef SEARCH_EXTS
  1371.     char *ext[] = { SEARCH_EXTS };
  1372.     int extidx = (strchr(scriptname,'.')) ? -1 : 0; /* has ext already */
  1373. #endif
  1374.  
  1375. #ifdef VMS
  1376.     if (dosearch && !strpbrk(scriptname,":[</") && (my_getenv("DCL$PATH"))) {
  1377.     int idx = 0;
  1378.  
  1379.     while (my_trnlnm("DCL$PATH",tokenbuf,idx++)) {
  1380.         strcat(tokenbuf,scriptname);
  1381. #else  /* !VMS */
  1382. #ifdef macintosh
  1383.    if (dosearch && !strchr(scriptname, ':') && (s = getenv("Commands"))) {
  1384. #else
  1385.    if (dosearch && !strchr(scriptname, '/') && (s = getenv("PATH"))) {
  1386. #endif
  1387.  
  1388.     bufend = s + strlen(s);
  1389.     while (*s) {
  1390. #ifndef DOSISH
  1391. #ifdef macintosh
  1392.         s = cpytill(tokenbuf,s,bufend,',',&len);
  1393. #else
  1394.         s = cpytill(tokenbuf,s,bufend,':',&len);
  1395. #endif
  1396. #else
  1397. #ifdef atarist
  1398.         for (len = 0; *s && *s != ',' && *s != ';'; tokenbuf[len++] = *s++);
  1399.         tokenbuf[len] = '\0';
  1400. #else
  1401.         for (len = 0; *s && *s != ';'; tokenbuf[len++] = *s++);
  1402.         tokenbuf[len] = '\0';
  1403. #endif
  1404. #endif
  1405.         if (*s)
  1406.         s++;
  1407. #ifdef macintosh
  1408.         if (len && tokenbuf[len-1] != ':')
  1409.         (void)strcat(tokenbuf+len,":");
  1410. #else
  1411. #ifndef DOSISH
  1412.         if (len && tokenbuf[len-1] != '/')
  1413. #else
  1414. #ifdef atarist
  1415.         if (len && ((tokenbuf[len-1] != '\\') && (tokenbuf[len-1] != '/')))
  1416. #else
  1417.         if (len && tokenbuf[len-1] != '\\')
  1418. #endif
  1419. #endif
  1420.         (void)strcat(tokenbuf+len,"/");
  1421. #endif
  1422.         (void)strcat(tokenbuf+len,scriptname);
  1423. #endif  /* !VMS */
  1424.  
  1425. #ifdef SEARCH_EXTS
  1426.         len = strlen(tokenbuf);
  1427.         if (extidx > 0)    /* reset after previous loop */
  1428.         extidx = 0;
  1429.         do {
  1430. #endif
  1431.             DEBUG_p(fprintf(Perl_debug_log,"Looking for %s\n",tokenbuf));
  1432.         retval = Stat(tokenbuf,&statbuf);
  1433. #ifdef SEARCH_EXTS
  1434.         } while (  retval < 0        /* not there */
  1435.             && extidx>=0 && ext[extidx]    /* try an extension? */
  1436.             && strcpy(tokenbuf+len, ext[extidx++])
  1437.         );
  1438. #endif
  1439.         if (retval < 0)
  1440.         continue;
  1441.         if (S_ISREG(statbuf.st_mode)
  1442. #ifdef macintosh
  1443.          && cando(S_IRUSR,TRUE,&statbuf)) {
  1444. #else
  1445.          && cando(S_IRUSR,TRUE,&statbuf) && cando(S_IXUSR,TRUE,&statbuf)) {
  1446. #endif
  1447.         xfound = tokenbuf;              /* bingo! */
  1448.         break;
  1449.         }
  1450.         if (!xfailed)
  1451.         xfailed = savepv(tokenbuf);
  1452.     }
  1453.     if (!xfound)
  1454.         croak("Can't execute %s", xfailed ? xfailed : scriptname );
  1455.     if (xfailed)
  1456.         Safefree(xfailed);
  1457.     scriptname = xfound;
  1458.     }
  1459.  
  1460.     origfilename = savepv(e_tmpname ? "-e" : scriptname);
  1461.     curcop->cop_filegv = gv_fetchfile(origfilename);
  1462.     if (strEQ(origfilename,"-"))
  1463.     scriptname = "";
  1464.     if (preprocess) {
  1465. #ifdef macintosh
  1466.     (void)sprintf(buf, 
  1467. "StreamEdit -e '/•[¬#]/"
  1468.                 "||/ç•#[ ∂t]*include[ ∂t]/"
  1469.         "||/ç•#[ ∂t]*define[ ∂t]/"
  1470.         "||/ç•#[ ∂t]*if[ ∂t]/"
  1471.         "||/ç•#[ ∂t]*ifdef[ ∂t]/"
  1472.         "||/ç•#[ ∂t]*ifndef[ ∂t]/"
  1473.         "||/ç•#[ ∂t]*else/"
  1474.         "||/ç•#[ ∂t]*elif/"
  1475.         "||/ç•#[ ∂t]*undef/"
  1476.         "||/ç•#[ ∂t]*endif/ Next' "
  1477.                "-e '/ç•[ ∂t]*#≈/ Delete' "
  1478. " %s | C -e %s",
  1479.       scriptname, SvPV(sv, na));
  1480. #else
  1481.     char *cpp = CPPSTDIN;
  1482.  
  1483.     if (strEQ(cpp,"cppstdin"))
  1484.         sprintf(tokenbuf, "%s/%s", SCRIPTDIR, cpp);
  1485.     else
  1486.         sprintf(tokenbuf, "%s", cpp);
  1487.     sv_catpv(sv,"-I");
  1488.     sv_catpv(sv,PRIVLIB_EXP);
  1489. #ifdef MSDOS
  1490.     (void)sprintf(buf, "\
  1491. sed %s -e \"/^[^#]/b\" \
  1492.  -e \"/^#[     ]*include[     ]/b\" \
  1493.  -e \"/^#[     ]*define[     ]/b\" \
  1494.  -e \"/^#[     ]*if[     ]/b\" \
  1495.  -e \"/^#[     ]*ifdef[     ]/b\" \
  1496.  -e \"/^#[     ]*ifndef[     ]/b\" \
  1497.  -e \"/^#[     ]*else/b\" \
  1498.  -e \"/^#[     ]*elif[     ]/b\" \
  1499.  -e \"/^#[     ]*undef[     ]/b\" \
  1500.  -e \"/^#[     ]*endif/b\" \
  1501.  -e \"s/^#.*//\" \
  1502.  %s | %s -C %s %s",
  1503.       (doextract ? "-e \"1,/^#/d\n\"" : ""),
  1504. #else
  1505.     (void)sprintf(buf, "\
  1506. %s %s -e '/^[^#]/b' \
  1507.  -e '/^#[     ]*include[     ]/b' \
  1508.  -e '/^#[     ]*define[     ]/b' \
  1509.  -e '/^#[     ]*if[     ]/b' \
  1510.  -e '/^#[     ]*ifdef[     ]/b' \
  1511.  -e '/^#[     ]*ifndef[     ]/b' \
  1512.  -e '/^#[     ]*else/b' \
  1513.  -e '/^#[     ]*elif[     ]/b' \
  1514.  -e '/^#[     ]*undef[     ]/b' \
  1515.  -e '/^#[     ]*endif/b' \
  1516.  -e 's/^[     ]*#.*//' \
  1517.  %s | %s -C %s %s",
  1518. #ifdef LOC_SED
  1519.       LOC_SED,
  1520. #else
  1521.       "sed",
  1522. #endif
  1523.       (doextract ? "-e '1,/^#/d\n'" : ""),
  1524. #endif
  1525.       scriptname, tokenbuf, SvPV(sv, na), CPPMINUS);
  1526. #endif
  1527.     doextract = FALSE;
  1528. #ifdef IAMSUID                /* actually, this is caught earlier */
  1529.     if (euid != uid && !euid) {    /* if running suidperl */
  1530. #ifdef HAS_SETEUID
  1531.         (void)seteuid(uid);        /* musn't stay setuid root */
  1532. #else
  1533. #ifdef HAS_SETREUID
  1534.         (void)setreuid((Uid_t)-1, uid);
  1535. #else
  1536. #ifdef HAS_SETRESUID
  1537.         (void)setresuid((Uid_t)-1, uid, (Uid_t)-1);
  1538. #else
  1539.         setuid(uid);
  1540. #endif
  1541. #endif
  1542. #endif
  1543.         if (geteuid() != uid)
  1544.         croak("Can't do seteuid!\n");
  1545.     }
  1546. #endif /* IAMSUID */
  1547.     rsfp = my_popen(buf,"r");
  1548.     }
  1549.     else if (!*scriptname) {
  1550.     taint_not("program input from stdin");
  1551.     rsfp = stdin;
  1552.     }
  1553.     else
  1554.     rsfp = fopen(scriptname,"r");
  1555.     if ((FILE*)rsfp == Nullfp) {
  1556. #ifdef DOSUID
  1557. #ifndef IAMSUID        /* in case script is not readable before setuid */
  1558.     if (euid && Stat(SvPVX(GvSV(curcop->cop_filegv)),&statbuf) >= 0 &&
  1559.       statbuf.st_mode & (S_ISUID|S_ISGID)) {
  1560.         (void)sprintf(buf, "%s/sperl%s", BIN, patchlevel);
  1561.         execv(buf, origargv);    /* try again */
  1562.         croak("Can't do setuid\n");
  1563.     }
  1564. #endif
  1565. #endif
  1566.     croak("Can't open perl script \"%s\": %s\n",
  1567.       SvPVX(GvSV(curcop->cop_filegv)), Strerror(errno));
  1568.     }
  1569. }
  1570.  
  1571. static void
  1572. validate_suid(validarg)
  1573. char *validarg;
  1574. {
  1575.     /* do we need to emulate setuid on scripts? */
  1576.  
  1577.     /* This code is for those BSD systems that have setuid #! scripts disabled
  1578.      * in the kernel because of a security problem.  Merely defining DOSUID
  1579.      * in perl will not fix that problem, but if you have disabled setuid
  1580.      * scripts in the kernel, this will attempt to emulate setuid and setgid
  1581.      * on scripts that have those now-otherwise-useless bits set.  The setuid
  1582.      * root version must be called suidperl or sperlN.NNN.  If regular perl
  1583.      * discovers that it has opened a setuid script, it calls suidperl with
  1584.      * the same argv that it had.  If suidperl finds that the script it has
  1585.      * just opened is NOT setuid root, it sets the effective uid back to the
  1586.      * uid.  We don't just make perl setuid root because that loses the
  1587.      * effective uid we had before invoking perl, if it was different from the
  1588.      * uid.
  1589.      *
  1590.      * DOSUID must be defined in both perl and suidperl, and IAMSUID must
  1591.      * be defined in suidperl only.  suidperl must be setuid root.  The
  1592.      * Configure script will set this up for you if you want it.
  1593.      */
  1594.  
  1595. #ifdef DOSUID
  1596.     char *s;
  1597.  
  1598.     if (Fstat(fileno(rsfp),&statbuf) < 0)    /* normal stat is insecure */
  1599.     croak("Can't stat script \"%s\"",origfilename);
  1600.     if (statbuf.st_mode & (S_ISUID|S_ISGID)) {
  1601.     I32 len;
  1602.  
  1603. #ifdef IAMSUID
  1604. #ifndef HAS_SETREUID
  1605.     /* On this access check to make sure the directories are readable,
  1606.      * there is actually a small window that the user could use to make
  1607.      * filename point to an accessible directory.  So there is a faint
  1608.      * chance that someone could execute a setuid script down in a
  1609.      * non-accessible directory.  I don't know what to do about that.
  1610.      * But I don't think it's too important.  The manual lies when
  1611.      * it says access() is useful in setuid programs.
  1612.      */
  1613.     if (access(SvPVX(GvSV(curcop->cop_filegv)),1))    /*double check*/
  1614.         croak("Permission denied");
  1615. #else
  1616.     /* If we can swap euid and uid, then we can determine access rights
  1617.      * with a simple stat of the file, and then compare device and
  1618.      * inode to make sure we did stat() on the same file we opened.
  1619.      * Then we just have to make sure he or she can execute it.
  1620.      */
  1621.     {
  1622.         struct stat tmpstatbuf;
  1623.  
  1624.         if (
  1625. #ifdef HAS_SETREUID
  1626.         setreuid(euid,uid) < 0
  1627. #else
  1628. # if HAS_SETRESUID
  1629.         setresuid(euid,uid,(Uid_t)-1) < 0
  1630. # endif
  1631. #endif
  1632.         || getuid() != euid || geteuid() != uid)
  1633.         croak("Can't swap uid and euid");    /* really paranoid */
  1634.         if (Stat(SvPVX(GvSV(curcop->cop_filegv)),&tmpstatbuf) < 0)
  1635.         croak("Permission denied");    /* testing full pathname here */
  1636.         if (tmpstatbuf.st_dev != statbuf.st_dev ||
  1637.         tmpstatbuf.st_ino != statbuf.st_ino) {
  1638.         (void)fclose(rsfp);
  1639.         if (rsfp = my_popen("/bin/mail root","w")) {    /* heh, heh */
  1640.             fprintf(rsfp,
  1641. "User %d tried to run dev %d ino %d in place of dev %d ino %d!\n\
  1642. (Filename of set-id script was %s, uid %d gid %d.)\n\nSincerely,\nperl\n",
  1643.             uid,tmpstatbuf.st_dev, tmpstatbuf.st_ino,
  1644.             statbuf.st_dev, statbuf.st_ino,
  1645.             SvPVX(GvSV(curcop->cop_filegv)),
  1646.             statbuf.st_uid, statbuf.st_gid);
  1647.             (void)my_pclose(rsfp);
  1648.         }
  1649.         croak("Permission denied\n");
  1650.         }
  1651.         if (
  1652. #ifdef HAS_SETREUID
  1653.               setreuid(uid,euid) < 0
  1654. #else
  1655. # if defined(HAS_SETRESUID)
  1656.               setresuid(uid,euid,(Uid_t)-1) < 0
  1657. # endif
  1658. #endif
  1659.               || getuid() != uid || geteuid() != euid)
  1660.         croak("Can't reswap uid and euid");
  1661.         if (!cando(S_IXUSR,FALSE,&statbuf))        /* can real uid exec? */
  1662.         croak("Permission denied\n");
  1663.     }
  1664. #endif /* HAS_SETREUID */
  1665. #endif /* IAMSUID */
  1666.  
  1667.     if (!S_ISREG(statbuf.st_mode))
  1668.         croak("Permission denied");
  1669.     if (statbuf.st_mode & S_IWOTH)
  1670.         croak("Setuid/gid script is writable by world");
  1671.     doswitches = FALSE;        /* -s is insecure in suid */
  1672.     curcop->cop_line++;
  1673.     if (fgets(tokenbuf,sizeof tokenbuf, rsfp) == Nullch ||
  1674.       strnNE(tokenbuf,"#!",2) )    /* required even on Sys V */
  1675.         croak("No #! line");
  1676.     s = tokenbuf+2;
  1677.     if (*s == ' ') s++;
  1678.     while (!isSPACE(*s)) s++;
  1679.     if (strnNE(s-4,"perl",4) && strnNE(s-9,"perl",4))  /* sanity check */
  1680.         croak("Not a perl script");
  1681.     while (*s == ' ' || *s == '\t') s++;
  1682.     /*
  1683.      * #! arg must be what we saw above.  They can invoke it by
  1684.      * mentioning suidperl explicitly, but they may not add any strange
  1685.      * arguments beyond what #! says if they do invoke suidperl that way.
  1686.      */
  1687.     len = strlen(validarg);
  1688.     if (strEQ(validarg," PHOOEY ") ||
  1689.         strnNE(s,validarg,len) || !isSPACE(s[len]))
  1690.         croak("Args must match #! line");
  1691.  
  1692. #ifndef IAMSUID
  1693.     if (euid != uid && (statbuf.st_mode & S_ISUID) &&
  1694.         euid == statbuf.st_uid)
  1695.         if (!do_undump)
  1696.         croak("YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
  1697. FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
  1698. #endif /* IAMSUID */
  1699.  
  1700.     if (euid) {    /* oops, we're not the setuid root perl */
  1701.         (void)fclose(rsfp);
  1702. #ifndef IAMSUID
  1703.         (void)sprintf(buf, "%s/sperl%s", BIN, patchlevel);
  1704.         execv(buf, origargv);    /* try again */
  1705. #endif
  1706.         croak("Can't do setuid\n");
  1707.     }
  1708.  
  1709.     if (statbuf.st_mode & S_ISGID && statbuf.st_gid != egid) {
  1710. #ifdef HAS_SETEGID
  1711.         (void)setegid(statbuf.st_gid);
  1712. #else
  1713. #ifdef HAS_SETREGID
  1714.            (void)setregid((Gid_t)-1,statbuf.st_gid);
  1715. #else
  1716. #ifdef HAS_SETRESGID
  1717.            (void)setresgid((Gid_t)-1,statbuf.st_gid,(Gid_t)-1);
  1718. #else
  1719.         setgid(statbuf.st_gid);
  1720. #endif
  1721. #endif
  1722. #endif
  1723.         if (getegid() != statbuf.st_gid)
  1724.         croak("Can't do setegid!\n");
  1725.     }
  1726.     if (statbuf.st_mode & S_ISUID) {
  1727.         if (statbuf.st_uid != euid)
  1728. #ifdef HAS_SETEUID
  1729.         (void)seteuid(statbuf.st_uid);    /* all that for this */
  1730. #else
  1731. #ifdef HAS_SETREUID
  1732.                 (void)setreuid((Uid_t)-1,statbuf.st_uid);
  1733. #else
  1734. #ifdef HAS_SETRESUID
  1735.                 (void)setresuid((Uid_t)-1,statbuf.st_uid,(Uid_t)-1);
  1736. #else
  1737.         setuid(statbuf.st_uid);
  1738. #endif
  1739. #endif
  1740. #endif
  1741.         if (geteuid() != statbuf.st_uid)
  1742.         croak("Can't do seteuid!\n");
  1743.     }
  1744.     else if (uid) {            /* oops, mustn't run as root */
  1745. #ifdef HAS_SETEUID
  1746.           (void)seteuid((Uid_t)uid);
  1747. #else
  1748. #ifdef HAS_SETREUID
  1749.           (void)setreuid((Uid_t)-1,(Uid_t)uid);
  1750. #else
  1751. #ifdef HAS_SETRESUID
  1752.           (void)setresuid((Uid_t)-1,(Uid_t)uid,(Uid_t)-1);
  1753. #else
  1754.           setuid((Uid_t)uid);
  1755. #endif
  1756. #endif
  1757. #endif
  1758.         if (geteuid() != uid)
  1759.         croak("Can't do seteuid!\n");
  1760.     }
  1761.     init_ids();
  1762.     if (!cando(S_IXUSR,TRUE,&statbuf))
  1763.         croak("Permission denied\n");    /* they can't do this */
  1764.     }
  1765. #ifdef IAMSUID
  1766.     else if (preprocess)
  1767.     croak("-P not allowed for setuid/setgid script\n");
  1768.     else
  1769.     croak("Script is not setuid/setgid in suidperl\n");
  1770. #endif /* IAMSUID */
  1771. #else /* !DOSUID */
  1772.     if (euid != uid || egid != gid) {    /* (suidperl doesn't exist, in fact) */
  1773. #ifndef SETUID_SCRIPTS_ARE_SECURE_NOW
  1774.     Fstat(fileno(rsfp),&statbuf);    /* may be either wrapped or real suid */
  1775.     if ((euid != uid && euid == statbuf.st_uid && statbuf.st_mode & S_ISUID)
  1776.         ||
  1777.         (egid != gid && egid == statbuf.st_gid && statbuf.st_mode & S_ISGID)
  1778.        )
  1779.         if (!do_undump)
  1780.         croak("YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
  1781. FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
  1782. #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
  1783.     /* not set-id, must be wrapped */
  1784.     }
  1785. #endif /* DOSUID */
  1786. }
  1787.  
  1788. static void
  1789. find_beginning()
  1790. {
  1791.     register char *s;
  1792.  
  1793.     /* skip forward in input to the real script? */
  1794.  
  1795.     taint_not("-x");
  1796. #ifdef macintosh
  1797.     /* Since the Mac OS does not honor !# arguments for us, we do it ourselves */
  1798.     
  1799.     while (doextract || gAlwaysExtract) {
  1800.     if ((s = sv_gets(linestr, rsfp, 0)) == Nullch) {
  1801.         if (!gAlwaysExtract)
  1802.             croak("No Perl script found in input\n");
  1803.         
  1804.         if (doextract)            /* require explicit override ? */
  1805.         if (!OverrideExtract(origfilename))
  1806.             croak("User aborted script\n");
  1807.         else
  1808.             doextract = FALSE;
  1809.         
  1810.         /* Pater peccavi, file does not have #! */
  1811.         rewind(rsfp);
  1812.         
  1813.         break;
  1814.     }
  1815. #else
  1816.     while (doextract) {
  1817.     if ((s = sv_gets(linestr, rsfp, 0)) == Nullch)
  1818.         croak("No Perl script found in input\n");
  1819. #endif
  1820.     if (*s == '#' && s[1] == '!' && instr(s,"perl")) {
  1821.         ungetc('\n',rsfp);        /* to keep line count right */
  1822.         doextract = FALSE;
  1823.         if (s = instr(s,"perl -")) {
  1824.         s += 6;
  1825.         /*SUPPRESS 530*/
  1826.         while (s = moreswitches(s)) ;
  1827.         }
  1828.         if (cddir && chdir(cddir) < 0)
  1829.         croak("Can't chdir to %s",cddir);
  1830. #ifdef macintosh
  1831.         break;
  1832. #endif
  1833.     }
  1834.     }
  1835. }
  1836.  
  1837. static void
  1838. init_ids()
  1839. {
  1840.     uid = (int)getuid();
  1841.     euid = (int)geteuid();
  1842.     gid = (int)getgid();
  1843.     egid = (int)getegid();
  1844. #ifdef VMS
  1845.     uid |= gid << 16;
  1846.     euid |= egid << 16;
  1847. #endif
  1848.     tainting |= (uid && (euid != uid || egid != gid));
  1849. }
  1850.  
  1851. static void
  1852. init_debugger()
  1853. {
  1854.     curstash = debstash;
  1855.     dbargs = GvAV(gv_AVadd((gv_fetchpv("args", GV_ADDMULTI, SVt_PVAV))));
  1856.     AvREAL_off(dbargs);
  1857.     DBgv = gv_fetchpv("DB", GV_ADDMULTI, SVt_PVGV);
  1858.     DBline = gv_fetchpv("dbline", GV_ADDMULTI, SVt_PVAV);
  1859.     DBsub = gv_HVadd(gv_fetchpv("sub", GV_ADDMULTI, SVt_PVHV));
  1860.     DBsingle = GvSV((gv_fetchpv("single", GV_ADDMULTI, SVt_PV)));
  1861.     sv_setiv(DBsingle, 0); 
  1862.     DBtrace = GvSV((gv_fetchpv("trace", GV_ADDMULTI, SVt_PV)));
  1863.     sv_setiv(DBtrace, 0); 
  1864.     DBsignal = GvSV((gv_fetchpv("signal", GV_ADDMULTI, SVt_PV)));
  1865.     sv_setiv(DBsignal, 0); 
  1866.     curstash = defstash;
  1867. }
  1868.  
  1869. static void
  1870. init_stacks()
  1871. {
  1872.     stack = newAV();
  1873.     mainstack = stack;            /* remember in case we switch stacks */
  1874.     AvREAL_off(stack);            /* not a real array */
  1875.     av_extend(stack,127);
  1876.  
  1877.     stack_base = AvARRAY(stack);
  1878.     stack_sp = stack_base;
  1879.     stack_max = stack_base + 127;
  1880.  
  1881.     /* Shouldn't these stacks be per-interpreter? */
  1882.     if (markstack) {
  1883.     markstack_ptr = markstack;
  1884.     } else {
  1885.     New(54,markstack,64,I32);
  1886.     markstack_ptr = markstack;
  1887.     markstack_max = markstack + 64;
  1888.     }
  1889.  
  1890.     if (scopestack) {
  1891.     scopestack_ix = 0;
  1892.     } else {
  1893.     New(54,scopestack,32,I32);
  1894.     scopestack_ix = 0;
  1895.     scopestack_max = 32;
  1896.     }
  1897.  
  1898.     if (savestack) {
  1899.     savestack_ix = 0;
  1900.     } else {
  1901.     New(54,savestack,128,ANY);
  1902.     savestack_ix = 0;
  1903.     savestack_max = 128;
  1904.     }
  1905.  
  1906.     if (retstack) {
  1907.     retstack_ix = 0;
  1908.     } else {
  1909.     New(54,retstack,16,OP*);
  1910.     retstack_ix = 0;
  1911.     retstack_max = 16;
  1912.    }
  1913.  
  1914.     cxstack_max = 8192 / sizeof(CONTEXT) - 2;    /* Use most of 8K. */
  1915.     New(50,cxstack,cxstack_max + 1,CONTEXT);
  1916.     cxstack_ix    = -1;
  1917.  
  1918.     New(50,tmps_stack,128,SV*);
  1919.     tmps_ix = -1;
  1920.     tmps_max = 128;
  1921.  
  1922.     DEBUG( {
  1923.     New(51,debname,128,char);
  1924.     New(52,debdelim,128,char);
  1925.     } )
  1926. }
  1927.  
  1928. static void
  1929. nuke_stacks()
  1930. {
  1931.     Safefree(cxstack);
  1932.     Safefree(tmps_stack);
  1933. }
  1934.  
  1935. static FILE *tmpfp;  /* moved outside init_lexer() because of UNICOS bug */
  1936. static void
  1937. init_lexer()
  1938. {
  1939.     tmpfp = rsfp;
  1940.  
  1941.     lex_start(linestr);
  1942.     rsfp = tmpfp;
  1943.     subname = newSVpv("main",4);
  1944. }
  1945.  
  1946. static void
  1947. init_predump_symbols()
  1948. {
  1949.     GV *tmpgv;
  1950.     GV *othergv;
  1951.  
  1952.     sv_setpvn(GvSV(gv_fetchpv("\"", TRUE, SVt_PV)), " ", 1);
  1953.  
  1954.     stdingv = gv_fetchpv("STDIN",TRUE, SVt_PVIO);
  1955.     GvMULTI_on(stdingv);
  1956.     IoIFP(GvIOp(stdingv)) = stdin;
  1957.     tmpgv = gv_fetchpv("stdin",TRUE, SVt_PV);
  1958.     GvMULTI_on(tmpgv);
  1959.     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(GvIOp(stdingv));
  1960.  
  1961.     tmpgv = gv_fetchpv("STDOUT",TRUE, SVt_PVIO);
  1962.     GvMULTI_on(tmpgv);
  1963.     IoOFP(GvIOp(tmpgv)) = IoIFP(GvIOp(tmpgv)) = stdout;
  1964.     setdefout(tmpgv);
  1965.     tmpgv = gv_fetchpv("stdout",TRUE, SVt_PV);
  1966.     GvMULTI_on(tmpgv);
  1967.     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(GvIOp(defoutgv));
  1968.  
  1969.     othergv = gv_fetchpv("STDERR",TRUE, SVt_PVIO);
  1970.     GvMULTI_on(othergv);
  1971.     IoOFP(GvIOp(othergv)) = IoIFP(GvIOp(othergv)) = stderr;
  1972.     tmpgv = gv_fetchpv("stderr",TRUE, SVt_PV);
  1973.     GvMULTI_on(tmpgv);
  1974.     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(GvIOp(othergv));
  1975.  
  1976.     statname = NEWSV(66,0);        /* last filename we did stat on */
  1977.  
  1978.     if (!osname)
  1979.     osname = savepv(OSNAME);
  1980. }
  1981.  
  1982. static void
  1983. init_postdump_symbols(argc,argv,env)
  1984. register int argc;
  1985. register char **argv;
  1986. register char **env;
  1987. {
  1988.     char *s;
  1989.     SV *sv;
  1990.     GV* tmpgv;
  1991.  
  1992.     argc--,argv++;    /* skip name of script */
  1993.     if (doswitches) {
  1994.     for (; argc > 0 && **argv == '-'; argc--,argv++) {
  1995.         if (!argv[0][1])
  1996.         break;
  1997.         if (argv[0][1] == '-') {
  1998.         argc--,argv++;
  1999.         break;
  2000.         }
  2001.         if (s = strchr(argv[0], '=')) {
  2002.         *s++ = '\0';
  2003.         sv_setpv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),s);
  2004.         }
  2005.         else
  2006.         sv_setiv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),1);
  2007.     }
  2008.     }
  2009.     toptarget = NEWSV(0,0);
  2010.     sv_upgrade(toptarget, SVt_PVFM);
  2011.     sv_setpvn(toptarget, "", 0);
  2012.     bodytarget = NEWSV(0,0);
  2013.     sv_upgrade(bodytarget, SVt_PVFM);
  2014.     sv_setpvn(bodytarget, "", 0);
  2015.     formtarget = bodytarget;
  2016.  
  2017.     tainted = 1;
  2018.     if (tmpgv = gv_fetchpv("0",TRUE, SVt_PV)) {
  2019. #ifdef macintosh
  2020.     sv_setpv(GvSV(tmpgv),MPWFileName(origfilename));
  2021. #else
  2022.     sv_setpv(GvSV(tmpgv),origfilename);
  2023. #endif
  2024.     magicname("0", "0", 1);
  2025.     }
  2026.     if (tmpgv = gv_fetchpv("\024",TRUE, SVt_PV))
  2027.     time(&basetime);
  2028.     if (tmpgv = gv_fetchpv("\030",TRUE, SVt_PV))
  2029.     sv_setpv(GvSV(tmpgv),origargv[0]);
  2030.     if (argvgv = gv_fetchpv("ARGV",TRUE, SVt_PVAV)) {
  2031.     GvMULTI_on(argvgv);
  2032.     (void)gv_AVadd(argvgv);
  2033.     av_clear(GvAVn(argvgv));
  2034.     for (; argc > 0; argc--,argv++) {
  2035.         av_push(GvAVn(argvgv),newSVpv(argv[0],0));
  2036.     }
  2037.     }
  2038.     if (envgv = gv_fetchpv("ENV",TRUE, SVt_PVHV)) {
  2039.     HV *hv;
  2040.     GvMULTI_on(envgv);
  2041.     hv = GvHVn(envgv);
  2042.     hv_clear(hv);
  2043. #ifdef macintosh
  2044.     env = environ;
  2045. #else
  2046. #ifndef VMS  /* VMS doesn't have environ array */
  2047.     /* Note that if the supplied env parameter is actually a copy
  2048.        of the global environ then it may now point to free'd memory
  2049.        if the environment has been modified since. To avoid this
  2050.        problem we treat env==NULL as meaning 'use the default'
  2051.     */
  2052.     if (!env)
  2053.         env = environ;
  2054.     if (env != environ) {
  2055.         environ[0] = Nullch;
  2056.         hv_magic(hv, envgv, 'E');
  2057.     }
  2058.     for (; *env; env++) {
  2059.         if (!(s = strchr(*env,'=')))
  2060.         continue;
  2061.         *s++ = '\0';
  2062.         sv = newSVpv(s--,0);
  2063.         sv_magic(sv, sv, 'e', *env, s - *env);
  2064.         (void)hv_store(hv, *env, s - *env, sv, 0);
  2065.         *s = '=';
  2066.     }
  2067. #endif
  2068. #endif
  2069. #ifdef DYNAMIC_ENV_FETCH
  2070.     HvNAME(hv) = savepv(ENV_HV_NAME);
  2071. #endif
  2072.     hv_magic(hv, envgv, 'E');
  2073.     }
  2074.     tainted = 0;
  2075.     if (tmpgv = gv_fetchpv("$",TRUE, SVt_PV))
  2076.     sv_setiv(GvSV(tmpgv),(I32)getpid());
  2077.  
  2078. }
  2079.  
  2080. static void
  2081. init_perllib()
  2082. {
  2083.     char *s;
  2084.     if (!tainting) {
  2085.     s = getenv("PERL5LIB");
  2086.     if (s)
  2087.         incpush(s);
  2088.     else
  2089.         incpush(getenv("PERLLIB"));
  2090.     }
  2091.  
  2092. #ifdef APPLLIB_EXP
  2093.     incpush(APPLLIB_EXP);
  2094. #endif
  2095.  
  2096. #ifdef ARCHLIB_EXP
  2097.     incpush(ARCHLIB_EXP);
  2098. #endif
  2099. #ifndef macintosh
  2100. #ifndef PRIVLIB_EXP
  2101. #define PRIVLIB_EXP "/usr/local/lib/perl5:/usr/local/lib/perl"
  2102. #endif
  2103.     incpush(PRIVLIB_EXP);
  2104. #endif
  2105. #ifdef SITEARCH_EXP
  2106.     incpush(SITEARCH_EXP);
  2107. #endif
  2108. #ifdef SITELIB_EXP
  2109.     incpush(SITELIB_EXP);
  2110. #endif
  2111. #ifdef OLDARCHLIB_EXP  /* 5.00[01] compatibility */
  2112.     incpush(OLDARCHLIB_EXP);
  2113. #endif
  2114.     
  2115.     if (!tainting)
  2116. #ifdef macintosh
  2117.     incpush(":");
  2118. #else
  2119.     incpush(".");
  2120. #endif
  2121. }
  2122.  
  2123. void
  2124. calllist(list)
  2125. AV* list;
  2126. {
  2127.     Sigjmp_buf oldtop;
  2128.     STRLEN len;
  2129.     line_t oldline = curcop->cop_line;
  2130.  
  2131.     Copy(top_env, oldtop, 1, Sigjmp_buf);
  2132.  
  2133.     while (AvFILL(list) >= 0) {
  2134.     CV *cv = (CV*)av_shift(list);
  2135.  
  2136.     SAVEFREESV(cv);
  2137.  
  2138.     switch (Sigsetjmp(top_env,1)) {
  2139.     case 0: {
  2140.         SV* atsv = GvSV(errgv);
  2141.         PUSHMARK(stack_sp);
  2142.         perl_call_sv((SV*)cv, G_EVAL|G_DISCARD);
  2143.         (void)SvPV(atsv, len);
  2144.         if (len) {
  2145.             Copy(oldtop, top_env, 1, Sigjmp_buf);
  2146.             curcop = &compiling;
  2147.             curcop->cop_line = oldline;
  2148. #ifdef macintosh
  2149.             if (list == beginav)
  2150.             sv_catpv(atsv, "# BEGIN failed--compilation aborted");
  2151.             else
  2152.             sv_catpv(atsv, "# END failed--cleanup aborted");
  2153. #else
  2154.             if (list == beginav)
  2155.             sv_catpv(atsv, "BEGIN failed--compilation aborted");
  2156.             else
  2157.             sv_catpv(atsv, "END failed--cleanup aborted");
  2158. #endif
  2159.             croak("%s", SvPVX(atsv));
  2160.         }
  2161.         }
  2162.         break;
  2163.     case 1:
  2164. #ifdef VMS
  2165.         statusvalue = 255;    /* XXX I don't think we use 1 anymore. */
  2166. #else
  2167.     statusvalue = 1;
  2168. #endif
  2169.         /* FALL THROUGH */
  2170.     case 2:
  2171.         /* my_exit() was called */
  2172.         curstash = defstash;
  2173.         if (endav)
  2174.         calllist(endav);
  2175.         FREETMPS;
  2176.         Copy(oldtop, top_env, 1, Sigjmp_buf);
  2177.         curcop = &compiling;
  2178.         curcop->cop_line = oldline;
  2179.         if (statusvalue) {
  2180.         if (list == beginav)
  2181.             croak("BEGIN failed--compilation aborted");
  2182.         else
  2183.             croak("END failed--cleanup aborted");
  2184.         }
  2185.         my_exit(statusvalue);
  2186.         /* NOTREACHED */
  2187.         return;
  2188.     case 3:
  2189.         if (!restartop) {
  2190.         fprintf(stderr, "panic: restartop\n");
  2191.         FREETMPS;
  2192.         break;
  2193.         }
  2194.         Copy(oldtop, top_env, 1, Sigjmp_buf);
  2195.         curcop = &compiling;
  2196.         curcop->cop_line = oldline;
  2197.         Siglongjmp(top_env, 3);
  2198.     }
  2199.     }
  2200.  
  2201.     Copy(oldtop, top_env, 1, Sigjmp_buf);
  2202. }
  2203.  
  2204.